FLAME: a formal framework for the automated analysis of software product lines validated by automated specification testing

In a literature review on the last 20 years of automated analysis of feature models, the formalization of analysis operations was identified as the most relevant challenge in the field. This formalization could provide very valuable assets for tool developers such as a precise definition of the analysis operations and, what is more, a reference implementation, i.e., a trustworthy, not necessarily efficient implementation to compare different tools outputs. In this article, we present the FLAME framework as the result of facing this challenge. FLAME is a formal framework that can be used to formally specify not only feature models, but other variability modeling languages (VML s) as well. This reusability is achieved by its two-layered architecture. The abstract foundation layer is the bottom layer in which all VML-independent analysis operations and concepts are specified. On top of the foundation layer, a family of characteristic model layers—one for each VML to be formally specified—can be developed by redefining some abstract types and relations. The verification and validation of FLAME has followed a process in which formal verification has been performed traditionally by manual theorem proving, but validation has been performed by integrating our experience on metamorphic testing of variability analysis tools, something that has shown to be much more effective than manually designed test cases. To follow this automated, test-based validation approach, the specification of FLAME, written in Z, was translated into Prolog and 20,000 random tests were automatically generated and executed. Tests results helped to discover some inconsistencies not only in the formal specification, but also in the previous informal definitions of the analysis operations and in current analysis tools. After this process, the Prolog implementation of FLAME is being used as a reference implementation for some tool developers, some analysis operations have been formally specified for the first time with more generic semantics, and more VML s are being formally specified using FLAME.     

SearchFill: A stochastic optimization code for detecting atomic vacancies in crystalline and non-crystalline systems

We present an implementation of a stochastic optimization algorithm applied to location of atomic vacancies. Our method labels an empty point in space as a vacancy site, if the total spatial overlap of a “virtual sphere”, centered around the point, with the surrounding atoms (and other vacancies) falls below a tolerance parameter. A Metropolis-like algorithm displaces the vacancies randomly, using an “overlap temperature” parameter to allow for acceptance of moves into regions with higher overlap, thus avoiding local minima. Once the algorithm has targeted a point with low overlap, the overlap temperature is decreased, and the method works as a steepest descent optimization.Our method, with only two free parameters, is able to detect the correct number and coordinates of vacancies in a wide spectrum of condensed-matter systems, from crystals to amorphous solids, in fact in any given set of atomic coordinates, without any need of comparison with a reference initial structure.     

Communication-efficient and crash-quiescent Omega with unknown membership

The failure detector class Omega (Ω) provides an eventual leader election functionality, i.e., eventually all correct processes permanently trust the same correct process. An algorithm is communication-efficient if the number of links that carry messages forever is bounded by n, being n the number of processes in the system. It has been defined that an algorithm is crash-quiescent if it eventually stops sending messages to crashed processes. In this regard, it has been recently shown the impossibility of implementing Ω crash quiescently without a majority of correct processes. We say that the membership is unknown if each process pi only knows its own identity and the number of processes in the system (that is, i and n), but pi does not know the identity of the rest of processes of the system. There is a type of link (denoted by ADD link) in which a bounded (but unknown) number of consecutive messages can be delayed or lost.In this work we present the first implementation (to our knowledge) of Ω in partially synchronous systems with ADD links and with unknown membership. Furthermore, it is the first implementation of Ω that combines two very interesting properties: communication-efficiency and crash-quiescence when the majority of processes are correct. Finally, we also obtain with the same algorithm a failure detector () such that every correct process eventually and permanently outputs the set of all correct processes.     

State of the art of frameworks and middleware for facilitating mobile and ubiquitous learning development

The emergence of mobile and ubiquitous technologies as important tools to complement formal learning has been accompanied by a growing interest in their educational benefits and applications. Mobile devices can be used to promote learning anywhere and anytime, to foster social learning and knowledge sharing, or to visualize augmented reality applications for learning purposes. However, the development of these applications is difficult for many researchers because it requires understanding many different protocols; dealing with distributed schemas, processes, platforms, and services; learning new programming languages; and interacting with different hardware sensors and drivers. For that reason, the use of frameworks and middleware that encapsulate part of this complexity appears to be fundamental to the further development of mobile learning projects. This study analyzes the state of the art of frameworks and middleware devoted to simplifying the development of mobile and ubiquitous learning applications. The results can be useful to many researchers involved in the development of projects using these technologies by providing an overview of the features implemented in each of these frameworks.     

Diagnosing and correcting design inconsistencies in source code with logical abduction

Correcting design decay in source code is not a trivial task. Diagnosing and subsequently correcting inconsistencies between a software system’s code and its design rules (e.g., database queries are only allowed in the persistence layer) and coding conventions can be complex, time-consuming and error-prone. Providing support for this process is therefore highly desirable, but of a far greater complexity than suggesting basic corrective actions for simplistic implementation problems (like the “declare a local variable for non-declared variable” suggested by Eclipse).We present an abductive reasoning approach to inconsistency correction that consists of (1) a means for developers to document and verify a system’s design and coding rules, (2) an abductive logic reasoner that hypothesizes possible causes of inconsistencies between the system’s code and the documented rules and (3) a library of corrective actions for each hypothesized cause. This work builds on our previous work, where we expressed design rules as equality relationships between sets of source code artifacts (e.g., the set of methods in the persistence layer is the same as the set of methods that query the database). In this paper, we generalize our approach to design rules expressed as user-defined binary relationships between two sets of source code artifacts (e.g., every state changing method should invoke a persistence method).We illustrate our approach on the design of IntensiVE, a tool suite that enables defining sets of source code artifacts intensionally (by means of logic queries) and verifying relationships between such sets.     

Impact of spatial effects on income segregation indices

Residential segregation is an inherently spatial phenomenon as it measures the separation of different types of people within a region. Whether measured with an explicitly spatial index, or a classic aspatial index, a region’s underlying spatial properties could manifest themselves in the magnitude of measured segregation. In this paper we implement a Monte Carlo simulation approach to investigate the properties of four segregation indices in regions built with specific spatial properties. This approach allows us to control the experiment in ways that empirical data do not. In general we confirm the expected results for the indices under various spatial properties, but some unexpected results emerge. Both the Dissimilarity Index and Neighborhood Sorting Index are sensitive to region size, but their spatial counterparts, the Adjusted Dissimilarity Index and Generalized Neighborhood Sorting Index, are generally immune to this problem. The paper also lends weight to concerns about the downward pressure on measured segregation when multiple neighborhoods are grouped into a single census tract. Finally, we discuss concerns about the way space is incorporated into segregation indices since the expected value of the spatial indices tested is lower than their aspatial counterparts.     

Schema-based Web wrapping

An effective solution to automate information extraction from Web pages is represented by wrappers. A wrapper associates a Web page with an XML document that represents part of the information in that page in a machine-readable format. Most existing wrapping approaches have traditionally focused on how to generate extraction rules, while they have ignored potential benefits deriving from the use of the schema of the information being extracted in the wrapper evaluation. In this paper, we investigate how the schema of extracted information can be effectively used in both the design and evaluation of a Web wrapper. We define a clean declarative semantics for schema-based wrappers by introducing the notion of (preferred) extraction model, which is essential to compute a valid XML document containing the information extracted from a Web page. We developed the SCRAP (SChema-based wRAPper for web data) system for the proposed schema-based wrapping approach, which also provides visual support tools to the wrapper designer. Moreover, we present a wrapper generalization framework to profitably speed up the design of schema-based wrappers. Experimental evaluation has shown that SCRAP wrappers are not only able to successfully extract the required data, but also they are robust to changes that may occur in the source Web pages.     

Adaptive soft k-nearest-neighbour classifiers

A novel classifier is introduced to overcome the limitations of the k-NN classification systems. It estimates the posterior class probabilities using a local Parzen window estimation with the k-nearest-neighbour prototypes (in the Euclidean sense) to the pattern to classify. A learning algorithm is also presented to reduce the number of data points to store. Experimental results in two hand-written classification problems demonstrate the potential of the proposed classification system.     

Entanglement of formation and concurrence for mixed states

We review some results on analytical computations of the measures for quantum entanglement: entanglement of formation and concurrence. We introduce some estimations of the lower bounds for the entanglement of formation in bipartite mixed states, and of lower bounds for the concurrence in bipartite and tripartite systems. The results on lower bounds for the concurrence are also generalized to arbitrary multipartite systems.     

ASIP-based reconfigurable architectures for power-efficient and real-time image/video processing

To meet both flexibility and performance requirements, particularly when implementing high-end real-time image/video processing algorithms, the paper proposes to combine the application specific instruction-set processor (ASIP) paradigm with the reconfigurable hardware one. As case studies, the design of partially reconfigurable ASIP (r-ASIP) architectures is presented for two classes of algorithms with widespread diffusion in image/video processing: motion estimation and retinex filtering. Design optimizations are addressed at both algorithmic and architectural levels. Special processor concepts used to trade-off performance versus flexibility and to enable new features of post-fabrication configurability are shown. Silicon implementation results are compared to known ASIC, DSP or reconfigurable designs; the proposed r-ASIPs stand for their better performance–flexibility figures in the respective algorithmic class.